home *** CD-ROM | disk | FTP | other *** search
/ OpenGL Superbible (2nd Edition) / OpenGL SuperBible e2.iso / tools / GLUT-3.7 / PROGS / EXAMPLES / DINOSPIN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-12  |  9.4 KB  |  353 lines
  1.  
  2. /* Copyright (c) Mark J. Kilgard, 1994.  */
  3.  
  4. /* This program is freely distributable without licensing fees 
  5.    and is provided without guarantee or warrantee expressed or 
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. /* New GLUT 3.0 glutGetModifiers() functionality used to make Shift-Left
  9.    mouse scale the dinosaur's size. */
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include <math.h>       /* for cos(), sin(), and sqrt() */
  15. #include <GL/glut.h>
  16. #include "trackball.h"
  17.  
  18. typedef enum {
  19.   RESERVED, BODY_SIDE, BODY_EDGE, BODY_WHOLE, ARM_SIDE, ARM_EDGE, ARM_WHOLE,
  20.   LEG_SIDE, LEG_EDGE, LEG_WHOLE, EYE_SIDE, EYE_EDGE, EYE_WHOLE, DINOSAUR
  21. } displayLists;
  22.  
  23. int spinning = 0, moving = 0;
  24. int beginx, beginy;
  25. int W = 300, H = 300;
  26. float curquat[4];
  27. float lastquat[4];
  28. GLdouble bodyWidth = 3.0;
  29. int newModel = 1;
  30. int scaling;
  31. float scalefactor = 1.0;
  32. /* *INDENT-OFF* */
  33. GLfloat body[][2] = { {0, 3}, {1, 1}, {5, 1}, {8, 4}, {10, 4}, {11, 5},
  34.   {11, 11.5}, {13, 12}, {13, 13}, {10, 13.5}, {13, 14}, {13, 15}, {11, 16},
  35.   {8, 16}, {7, 15}, {7, 13}, {8, 12}, {7, 11}, {6, 6}, {4, 3}, {3, 2},
  36.   {1, 2} };
  37. GLfloat arm[][2] = { {8, 10}, {9, 9}, {10, 9}, {13, 8}, {14, 9}, {16, 9},
  38.   {15, 9.5}, {16, 10}, {15, 10}, {15.5, 11}, {14.5, 10}, {14, 11}, {14, 10},
  39.   {13, 9}, {11, 11}, {9, 11} };
  40. GLfloat leg[][2] = { {8, 6}, {8, 4}, {9, 3}, {9, 2}, {8, 1}, {8, 0.5}, {9, 0},
  41.   {12, 0}, {10, 1}, {10, 2}, {12, 4}, {11, 6}, {10, 7}, {9, 7} };
  42. GLfloat eye[][2] = { {8.75, 15}, {9, 14.7}, {9.6, 14.7}, {10.1, 15},
  43.   {9.6, 15.25}, {9, 15.25} };
  44. GLfloat lightZeroPosition[] = {10.0, 4.0, 10.0, 1.0};
  45. GLfloat lightZeroColor[] = {0.8, 1.0, 0.8, 1.0}; /* green-tinted */
  46. GLfloat lightOnePosition[] = {-1.0, -2.0, 1.0, 0.0};
  47. GLfloat lightOneColor[] = {0.6, 0.3, 0.2, 1.0}; /* red-tinted */
  48. GLfloat skinColor[] = {0.1, 1.0, 0.1, 1.0}, eyeColor[] = {1.0, 0.2, 0.2, 1.0};
  49. /* *INDENT-ON* */
  50.  
  51. void
  52. extrudeSolidFromPolygon(GLfloat data[][2], unsigned int dataSize,
  53.   GLdouble thickness, GLuint side, GLuint edge, GLuint whole)
  54. {
  55.   static GLUtriangulatorObj *tobj = NULL;
  56.   GLdouble vertex[3], dx, dy, len;
  57.   int i;
  58.   int count = (int) (dataSize / (2 * sizeof(GLfloat)));
  59.  
  60.   if (tobj == NULL) {
  61.     tobj = gluNewTess();  /* create and initialize a GLU
  62.                              polygon tesselation object */
  63.     gluTessCallback(tobj, GLU_BEGIN, glBegin);
  64.     gluTessCallback(tobj, GLU_VERTEX, glVertex2fv);  /* semi-tricky 
  65.  
  66.                                                       */
  67.     gluTessCallback(tobj, GLU_END, glEnd);
  68.   }
  69.   glNewList(side, GL_COMPILE);
  70.   glShadeModel(GL_SMOOTH);  /* smooth minimizes seeing
  71.                                tessellation */
  72.   gluBeginPolygon(tobj);
  73.   for (i = 0; i < count; i++) {
  74.     vertex[0] = data[i][0];
  75.     vertex[1] = data[i][1];
  76.     vertex[2] = 0;
  77.     gluTessVertex(tobj, vertex, data[i]);
  78.   }
  79.   gluEndPolygon(tobj);
  80.   glEndList();
  81.   glNewList(edge, GL_COMPILE);
  82.   glShadeModel(GL_FLAT);  /* flat shade keeps angular hands
  83.                              from being * * "smoothed" */
  84.   glBegin(GL_QUAD_STRIP);
  85.   for (i = 0; i <= count; i++) {
  86.     /* mod function handles closing the edge */
  87.     glVertex3f(data[i % count][0], data[i % count][1], 0.0);
  88.     glVertex3f(data[i % count][0], data[i % count][1], thickness);
  89.     /* Calculate a unit normal by dividing by Euclidean
  90.        distance. We * could be lazy and use
  91.        glEnable(GL_NORMALIZE) so we could pass in * arbitrary
  92.        normals for a very slight performance hit. */
  93.     dx = data[(i + 1) % count][1] - data[i % count][1];
  94.     dy = data[i % count][0] - data[(i + 1) % count][0];
  95.     len = sqrt(dx * dx + dy * dy);
  96.     glNormal3f(dx / len, dy / len, 0.0);
  97.   }
  98.   glEnd();
  99.   glEndList();
  100.   glNewList(whole, GL_COMPILE);
  101.   glFrontFace(GL_CW);
  102.   glCallList(edge);
  103.   glNormal3f(0.0, 0.0, -1.0);  /* constant normal for side */
  104.   glCallList(side);
  105.   glPushMatrix();
  106.   glTranslatef(0.0, 0.0, thickness);
  107.   glFrontFace(GL_CCW);
  108.   glNormal3f(0.0, 0.0, 1.0);  /* opposite normal for other side 
  109.  
  110.                                */
  111.   glCallList(side);
  112.   glPopMatrix();
  113.   glEndList();
  114. }
  115.  
  116. void
  117. makeDinosaur(void)
  118. {
  119.   extrudeSolidFromPolygon(body, sizeof(body), bodyWidth,
  120.     BODY_SIDE, BODY_EDGE, BODY_WHOLE);
  121.   extrudeSolidFromPolygon(arm, sizeof(arm), bodyWidth / 4,
  122.     ARM_SIDE, ARM_EDGE, ARM_WHOLE);
  123.   extrudeSolidFromPolygon(leg, sizeof(leg), bodyWidth / 2,
  124.     LEG_SIDE, LEG_EDGE, LEG_WHOLE);
  125.   extrudeSolidFromPolygon(eye, sizeof(eye), bodyWidth + 0.2,
  126.     EYE_SIDE, EYE_EDGE, EYE_WHOLE);
  127.   glNewList(DINOSAUR, GL_COMPILE);
  128.   glMaterialfv(GL_FRONT, GL_DIFFUSE, skinColor);
  129.   glCallList(BODY_WHOLE);
  130.   glPushMatrix();
  131.   glTranslatef(0.0, 0.0, bodyWidth);
  132.   glCallList(ARM_WHOLE);
  133.   glCallList(LEG_WHOLE);
  134.   glTranslatef(0.0, 0.0, -bodyWidth - bodyWidth / 4);
  135.   glCallList(ARM_WHOLE);
  136.   glTranslatef(0.0, 0.0, -bodyWidth / 4);
  137.   glCallList(LEG_WHOLE);
  138.   glTranslatef(0.0, 0.0, bodyWidth / 2 - 0.1);
  139.   glMaterialfv(GL_FRONT, GL_DIFFUSE, eyeColor);
  140.   glCallList(EYE_WHOLE);
  141.   glPopMatrix();
  142.   glEndList();
  143. }
  144.  
  145. void
  146. recalcModelView(void)
  147. {
  148.   GLfloat m[4][4];
  149.  
  150.   glPopMatrix();
  151.   glPushMatrix();
  152.   build_rotmatrix(m, curquat);
  153.   glMultMatrixf(&m[0][0]);
  154.   if (scalefactor == 1.0) {
  155.     glDisable(GL_NORMALIZE);
  156.   } else {
  157.     glEnable(GL_NORMALIZE);
  158.   }
  159.   glScalef(scalefactor, scalefactor, scalefactor);
  160.   glTranslatef(-8, -8, -bodyWidth / 2);
  161.   newModel = 0;
  162. }
  163.  
  164. void
  165. showMessage(GLfloat x, GLfloat y, GLfloat z, char *message)
  166. {
  167.   glPushMatrix();
  168.   glDisable(GL_LIGHTING);
  169.   glTranslatef(x, y, z);
  170.   glScalef(.02, .02, .02);
  171.   while (*message) {
  172.     glutStrokeCharacter(GLUT_STROKE_ROMAN, *message);
  173.     message++;
  174.   }
  175.   glEnable(GL_LIGHTING);
  176.   glPopMatrix();
  177. }
  178.  
  179. void
  180. redraw(void)
  181. {
  182.   if (newModel)
  183.     recalcModelView();
  184.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  185.   glCallList(DINOSAUR);
  186.   showMessage(2, 7.1, 4.1, "Spin me.");
  187.   glutSwapBuffers();
  188. }
  189.  
  190. void
  191. myReshape(int w, int h)
  192. {
  193.   glViewport(0, 0, w, h);
  194.   W = w;
  195.   H = h;
  196. }
  197.  
  198. void
  199. mouse(int button, int state, int x, int y)
  200. {
  201.   if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  202.     spinning = 0;
  203.     glutIdleFunc(NULL);
  204.     moving = 1;
  205.     beginx = x;
  206.     beginy = y;
  207.     if (glutGetModifiers() & GLUT_ACTIVE_SHIFT) {
  208.       scaling = 1;
  209.     } else {
  210.       scaling = 0;
  211.     }
  212.   }
  213.   if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {
  214.     moving = 0;
  215.   }
  216. }
  217.  
  218. void
  219. animate(void)
  220. {
  221.   add_quats(lastquat, curquat, curquat);
  222.   newModel = 1;
  223.   glutPostRedisplay();
  224. }
  225.  
  226. void
  227. motion(int x, int y)
  228. {
  229.   if (scaling) {
  230.     scalefactor = scalefactor * (1.0 + (((float) (beginy - y)) / H));
  231.     beginx = x;
  232.     beginy = y;
  233.     newModel = 1;
  234.     glutPostRedisplay();
  235.     return;
  236.   }
  237.   if (moving) {
  238.     trackball(lastquat,
  239.       (2.0 * beginx - W) / W,
  240.       (H - 2.0 * beginy) / H,
  241.       (2.0 * x - W) / W,
  242.       (H - 2.0 * y) / H
  243.       );
  244.     beginx = x;
  245.     beginy = y;
  246.     spinning = 1;
  247.     glutIdleFunc(animate);
  248.   }
  249. }
  250.  
  251. GLboolean lightZeroSwitch = GL_TRUE, lightOneSwitch = GL_TRUE;
  252.  
  253. void
  254. controlLights(int value)
  255. {
  256.   switch (value) {
  257.   case 1:
  258.     lightZeroSwitch = !lightZeroSwitch;
  259.     if (lightZeroSwitch) {
  260.       glEnable(GL_LIGHT0);
  261.     } else {
  262.       glDisable(GL_LIGHT0);
  263.     }
  264.     break;
  265.   case 2:
  266.     lightOneSwitch = !lightOneSwitch;
  267.     if (lightOneSwitch) {
  268.       glEnable(GL_LIGHT1);
  269.     } else {
  270.       glDisable(GL_LIGHT1);
  271.     }
  272.     break;
  273. #ifdef GL_MULTISAMPLE_SGIS
  274.   case 3:
  275.     if (glIsEnabled(GL_MULTISAMPLE_SGIS)) {
  276.       glDisable(GL_MULTISAMPLE_SGIS);
  277.     } else {
  278.       glEnable(GL_MULTISAMPLE_SGIS);
  279.     }
  280.     break;
  281. #endif
  282.   case 4:
  283.     glutFullScreen();
  284.     break;
  285.   case 5:
  286.     exit(0);
  287.     break;
  288.   }
  289.   glutPostRedisplay();
  290. }
  291.  
  292. void
  293. vis(int visible)
  294. {
  295.   if (visible == GLUT_VISIBLE) {
  296.     if (spinning)
  297.       glutIdleFunc(animate);
  298.   } else {
  299.     if (spinning)
  300.       glutIdleFunc(NULL);
  301.   }
  302. }
  303.  
  304. int
  305. main(int argc, char **argv)
  306. {
  307.   glutInit(&argc, argv);
  308.   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
  309.   trackball(curquat, 0.0, 0.0, 0.0, 0.0);
  310.   glutCreateWindow("dinospin");
  311.   glutDisplayFunc(redraw);
  312.   glutReshapeFunc(myReshape);
  313.   glutVisibilityFunc(vis);
  314.   glutMouseFunc(mouse);
  315.   glutMotionFunc(motion);
  316.   glutCreateMenu(controlLights);
  317.   glutAddMenuEntry("Toggle right light", 1);
  318.   glutAddMenuEntry("Toggle left light", 2);
  319.   if (glutGet(GLUT_WINDOW_NUM_SAMPLES) > 0) {
  320.     glutAddMenuEntry("Toggle multisampling", 3);
  321.     glutSetWindowTitle("dinospin (multisample capable)");
  322.   }
  323.   glutAddMenuEntry("Full screen", 4);
  324.   glutAddMenuEntry("Quit", 5);
  325.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  326.   makeDinosaur();
  327.   glEnable(GL_CULL_FACE);
  328.   glEnable(GL_DEPTH_TEST);
  329.   glEnable(GL_LIGHTING);
  330.   glMatrixMode(GL_PROJECTION);
  331.   gluPerspective( /* field of view in degree */ 40.0,
  332.   /* aspect ratio */ 1.0,
  333.     /* Z near */ 1.0, /* Z far */ 40.0);
  334.   glMatrixMode(GL_MODELVIEW);
  335.   gluLookAt(0.0, 0.0, 30.0,  /* eye is at (0,0,30) */
  336.     0.0, 0.0, 0.0,      /* center is at (0,0,0) */
  337.     0.0, 1.0, 0.);      /* up is in positive Y direction */
  338.   glPushMatrix();       /* dummy push so we can pop on model
  339.                            recalc */
  340.   glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
  341.   glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition);
  342.   glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor);
  343.   glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1);
  344.   glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05);
  345.   glLightfv(GL_LIGHT1, GL_POSITION, lightOnePosition);
  346.   glLightfv(GL_LIGHT1, GL_DIFFUSE, lightOneColor);
  347.   glEnable(GL_LIGHT0);
  348.   glEnable(GL_LIGHT1);
  349.   glLineWidth(2.0);
  350.   glutMainLoop();
  351.   return 0;             /* ANSI C requires main to return int. */
  352. }
  353.